package com.springapp.service.impl;

import com.springapp.connexion.SessionBean;
import com.springapp.dao.dao.impl.*;
import com.springapp.model.*;
import com.springapp.service.IListeTachesService;
import org.json.JSONException;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * Created by Thomas on 23/06/14.
 */

@Service
public class ListeTachesService implements IListeTachesService {
    // La liste Globale des taches demandée
    private List<Tache> lstTachesGlobal = new ArrayList<Tache>();
    @Autowired
    private SessionBean sessionBean;

    @Autowired
    private ListeTacheDAO listeTacheDAO;

    @Autowired
    private ArtConditionnementService artCondSce;
    @Autowired
    private PaletteEnStockDAO palEnStockDAO;
    @Autowired
    private MouvementDAO mouvementDAO;
    @Autowired
    private EmplacementDAO emplacementDAO;
    @Autowired
    private PalArtFouDAO palArtFouDAO;

    private int cptTache=0;
    public SessionBean getSessionBean(){
        return sessionBean;
    }

    public void setSessionBean(SessionBean sessionBean){
        this.sessionBean=sessionBean;
    }
    public List<Tache> getLstTachesglobal(){
        return lstTachesGlobal;
    }


    @Override
    public Tache getTacheAuto() {

    /*
        Création manuelle de taches afin de tester les listes
    */
//        if(lstTachesGlobal.size()==0){
//            ajouteTache(new Tache("26/08/2014", "15:10", "allee 7 rang 12", "allee 1 rang 5", "Micro-Onde", 30, 1, 1500, "", new ArrayList<String>(), 1, 1, 8, 4));
//            ajouteTache(new Tache("26/08/2014", "15:15", "allee 8 rang 13", "allee 2 rang 7", "Pots de peinture", 30, 1, 1501, "", new ArrayList<String>(), 1, 2, 2, 2));
//            ajouteTache(new Tache("26/08/2014", "15:20", "allee 7 rang 12", "allee 3 rang 8", "Meuble Living", 30, 1, 1502, "", new ArrayList<String>(), 1, 2, 2, 4));
//            ajouteTache(new Tache("26/08/2014", "15:30", "allee 8 rang 13", "allee 4 rang 9", "Polo London Marathon", 30, 1, 1503, "", new ArrayList<String>(), 1, 2, 2, 2));
//            ajouteTache(new Tache("26/08/2014", "15:50", "allee 7 rang 12", "allee 5 rang 10", "Ordinateur", 30, 1, 1504, "", new ArrayList<String>(), 1, 2, 2, 2));
//        }
    /*
    Fin de la création manuelle des taches pour tests
    */

        String _sMatricule= sessionBean.getUtilisateurFromSession().getsLogin();
        /////////////////////////////////// GESTION DES TACHES /////////////////////////////////////////
        //statut : 0 Terminée
        //statut : 1 en attente
        //statut : 2 affectée
        Tache clTache=new Tache();
        boolean bEstAttribuee = false;
        for(Tache cTache : lstTachesGlobal){
            //Attribution de la premiere tache non affectée de la liste et selon le profil
           //gestion des taches déja attribuée à ce user et qui sont toujours en cours
           if(cTache.getsMatricule().equals(sessionBean.getUtilisateurFromSession().getsLogin()) && cTache.getiStatut()==2){
               clTache=cTache;
               clTache.setsMatricule(_sMatricule);
               clTache.setiStatut(2);
               bEstAttribuee=true;
           }else{
               if(cTache.getsMatricule().equals("") && bEstAttribuee==false && cTache.getiIDProfil()==sessionBean.getUtilisateurFromSession().geteIDProfil()){
                    //alors on l'ajoute à la liste des taches de l'utilisateur afin de la renvoyer
                   clTache=cTache;
                   clTache.setsMatricule(_sMatricule);
                   clTache.setiStatut(2);
                   bEstAttribuee=true;
               }
           }
        }
        return clTache;

    }

    @Override
    public String PaletteOK(int _iIDPalette,int _iIDArtFou,int _iNbArt,int _idZoneDepart){
                /*
        Cette methode renvoi un indice sur la vérification de la palette scannée par rapport à celle attendue ainsi que l'ID palette dans un JSON.
        Cela afin d'être exploité par le code Ajax afin de mettre à jour la ligne de la tache actuelle.
        Elle n'est utilisée que pour controler des palette homogènes.
        Valeurs de retour :
        0 => OK
        1 => IDPalette n'existe pas
        2 => le nombre d'articles de cettte palette ne correspondent pas au nombre attendu
        3 => mauvais article ou mauvais fournisseur
        4 => pb de cohérence dans les données qui fait échouer la requête
        5 => palette hétérogene
         */
        String sRet="";
        JSONObject jsoTemp = new JSONObject();
        Palette pal = new Palette();
        String sMajEmp ="";
        int iCtrl=10;
        int iTmp;
        int iNbArtPalMax=0;
        pal=palEnStockDAO.getPalette(_iIDPalette);
        if(pal!=null){
            System.out.println("Emp Pal : "+pal.geteIDEmplacement()+" // Zonescannée : "+_idZoneDepart);
            if(pal.geteIDEmplacement()==_idZoneDepart){
                List<Pal_ArtFou> lstPalArtFou = new ArrayList<Pal_ArtFou>();
                List<ArtConditionnement> lstArtCond= new ArrayList<ArtConditionnement>();
                lstPalArtFou=listeTacheDAO.getListPalArtFou(_iIDPalette);
                if(lstPalArtFou.size()>0){
                    if(!pal.isbEstHeterogène()){ // palette homogène donc on peut vérifier si elle match les critères demandés
                        int nbArtMaxPalette = 0;
                        if(lstPalArtFou.get(0).geteIDArtFou()==_iIDArtFou){ //il s''agit bien du bon couple Article / Fournisseur
                            for(ArtConditionnement artCond : lstArtCond){ // on boucle pour calculer la capacité maximale de la palette
                                iTmp=artCond.geteUnite();
                                if(iNbArtPalMax==0){
                                    iNbArtPalMax=iTmp;
                                }else{
                                    iNbArtPalMax=iNbArtPalMax*iTmp;
                                }
                            }
                            if(iNbArtPalMax!=_iNbArt){
                                iCtrl=0;//la palette est OK , on peut la sortir de l'emplacement et mettre a jour la table emplacement
                                Emplacement emp = new Emplacement();
                                emp = emplacementDAO.getEmplacement(pal.geteIDEmplacement());
                                emp.setiQteActuelleZS(emp.getiQteActuelleZS()-1);
                                sMajEmp=emplacementDAO.update(emp);
                                sRet=sMajEmp;
                                // ensuite nous mettons a jour l'emplacement de la palette avec un emplacement intermédiaire => en mouvement
                                pal.seteIDEmplacement(999999);
                                palEnStockDAO.update(pal);
                            }else{
                                iCtrl=2;
                                sRet="Le nombre d'article de la palette n'est pas cohérent";
                            }

                        }
                    }else{
                        sRet="La Palette scannée est hétérogène";
                        iCtrl=5;
                    } // la palette est hétérogène donc c'est une palette en préparation
                }else{
                    sRet="Impossible de déterminer le contenu de la palette";
                    iCtrl=3;
                }
            }else{
                sRet="Cette palette n'est pas référencée dans cette zone";
                iCtrl=6;
            }
        }else{
            iCtrl=1;
            sRet = "Palette inconnue dans la base";
        }
        try {
            jsoTemp.put("CodeRetourMatch",iCtrl);
            jsoTemp.put("IDPalette",_iIDPalette);
            jsoTemp.put("Message",sRet);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        sRet= jsoTemp.toString();
        return sRet;
    }

    public String getLibEmplacement(int _iDEmplacement){
        String sRep=listeTacheDAO.getLibEmplacement(_iDEmplacement);
        return sRep;
    }

    public String verifEmplacement(int _iDEmplacement,int _idEmplacementTache){
        String sRep;
        if(_iDEmplacement==_idEmplacementTache){
            sRep=listeTacheDAO.getLibEmplacement(_iDEmplacement);
        }else{
            sRep = "La zone ne correspond pas";
        }
        return sRep;
    }

    public void supprimeTache(int _IDTache){
        int i=0;
        int iSavei=0;
        for(Tache cTacheTmp : lstTachesGlobal){
            if(cTacheTmp.getiIdTache()==_IDTache){
                iSavei=i;
            }
            i++;
        }
        lstTachesGlobal.remove(iSavei);
    }

    public void ajouteTache(Tache clTache){
        cptTache++;
        clTache.setiIdTache(cptTache);
        lstTachesGlobal.add(clTache);
    }

    public String achemineInterne(int _Zonedepart,int _iZoneDemandee,int _iIDPalette,int _iZoneDepot){
        String sRet = "Echec de l'enregistrement du mouvement";
        System.out.println("iZoneDemandee : "+_iZoneDemandee+" // iZoneDepot : "+_iZoneDepot);
        if(_iZoneDemandee==_iZoneDepot){
            Palette pal = new Palette();
            pal=palEnStockDAO.getPalette(_iIDPalette);

            // Enregistrement du mouvement d'arrivée

            Mouvement mouv=new Mouvement();
            List<Pal_ArtFou> lstPalArtFou = new ArrayList<Pal_ArtFou>();
            lstPalArtFou=listeTacheDAO.getListPalArtFou(_iIDPalette);
            int iCpt = lstPalArtFou.size();
            if(iCpt>0){
                for(int i=0;i==iCpt-1;i++){
                    mouv.setsLibelle("Interne");
                    mouv.seteIDTypeMvt(10);
                    mouv.seteIncident(0);
                    mouv.setsLieuDepart(getLibEmplacement(_Zonedepart));
                    mouv.setsLieuArrivee(getLibEmplacement(_iZoneDepot));
                    mouv.seteIDPalette(_iIDPalette);
                    mouv.seteIdArtFou(lstPalArtFou.get(i).geteIDArtFou());
                    mouv.seteQteArticle(lstPalArtFou.get(i).geteQteArticle());
                    Date dDateInstant = new Date();
                    SimpleDateFormat formater = null;
                    formater= new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                    mouv.setdDateInstant(formater.format(dDateInstant));
                    sRet=mouvementDAO.insert(mouv);
                }
            }

            //enregistrement du nouvel emplacement pour la palette
            pal.seteIDEmplacement(_iZoneDepot);
            palEnStockDAO.update(pal);
        }else{
            sRet = "La zone scannée ne correspond pas à la zone demandée";
        }
        return sRet;
    }
    public String enregIncident(Mouvement mouv, int _iIdEmplacement){
        String sRet="";
        JSONObject jsoRet= new JSONObject();
        jsoRet=palEnStockDAO.getQteArtFou(mouv.geteIDPalette());
        try {
            mouv.seteIdArtFou(jsoRet.getInt("IdArtFou"));
            if(mouv.geteQteArticle()==0){
                mouv.seteQteArticle(jsoRet.getInt("QteArticle"));
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        SimpleDateFormat formater = null;
        Date dDateInstant=new Date();
        formater= new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        mouv.setdDateInstant(formater.format(dDateInstant));
        sRet = mouvementDAO.insert(mouv);
        switch(mouv.geteIncident()){
            case 1 : //Palettes Absentes de l'emplacement => on met le stockage de l'emplacement à 0
                Emplacement emplacement=emplacementDAO.getEmplacement(_iIdEmplacement);
                emplacement.setiQteActuelleZS(0);
                emplacementDAO.update(emplacement);
                break;
            case 2 : // Contenu non conforme => changement de l'IDArtFou sur cette palette
                JSONObject jsoTmp = new JSONObject();
                jsoTmp=palArtFouDAO.getQteArtFou(mouv.geteIDPalette());
                Pal_ArtFou partf = new Pal_ArtFou();
                partf=palArtFouDAO.getPal_ArtFouFromPal(mouv.geteIDPalette());
                partf.seteIDArtFou(mouv.geteIdArtFou());
                palArtFouDAO.update(partf);

                break;
            case 4 : case 5 :case 6 : // articles endommagés , Feu , Déterioration diverse .. => on modifie le nombre d'article sur la palette dans PalArtFou
                Pal_ArtFou palartfou = new Pal_ArtFou();
                palartfou=palArtFouDAO.getPal_ArtFouFromPal(mouv.geteIDPalette());
                palartfou.seteQteArticle(palartfou.geteQteArticle()-mouv.geteQteArticle());
                palArtFouDAO.update(palartfou);
                // ensuite on remet la palette dans la zone de stockage incident ID 999998
                Palette palette=new Palette();
                palette=palEnStockDAO.getPalette(mouv.geteIDPalette());
                palette.seteIDEmplacement(999998);
                palEnStockDAO.update(palette);
                break;

        }
        return sRet;
    }
}
